പൈത്തൺ ഫാസ്റ്റ്‌എപിഐ മിഡിൽവെയർ: റിക്വസ്റ്റ്, റെസ്‌പോൺസ് പ്രോസസ്സിംഗിനായുള്ള ഒരു സമഗ്ര ഗൈഡ്

ആധുനിക വെബ് ഡെവലപ്‌മെന്റിന്റെ ലോകത്ത്, പ്രകടനം, സുരക്ഷ, പരിപാലനം എന്നിവ വളരെ പ്രധാനമാണ്. പൈത്തണിന്റെ ഫാസ്റ്റ്‌എപിഐ ഫ്രെയിംവർക്ക് അതിന്റെ അവിശ്വസനീയമായ വേഗതയും ഡെവലപ്പർ-ഫ്രണ്ട്ലി ഫീച്ചറുകളും കാരണം അതിവേഗം പ്രചാരം നേടി. അതിന്റെ ഏറ്റവും ശക്തമായ, എന്നാൽ ചിലപ്പോൾ തെറ്റിദ്ധരിക്കപ്പെടുന്ന ഒരു സവിശേഷതയാണ് മിഡിൽവെയർ. ഒരു റിക്വസ്റ്റ് അതിന്റെ ലക്ഷ്യസ്ഥാനത്ത് എത്തുന്നതിനോ അല്ലെങ്കിൽ ഒരു റെസ്‌പോൺസ് ക്ലയിന്റിലേക്ക് തിരികെ അയക്കുന്നതിനോ മുമ്പായി കോഡ് പ്രവർത്തിപ്പിക്കാനും, ഡാറ്റ പരിഷ്കരിക്കാനും, നിയമങ്ങൾ നടപ്പിലാക്കാനും ഡെവലപ്പർമാരെ അനുവദിക്കുന്ന, റിക്വസ്റ്റ്, റെസ്‌പോൺസ് പ്രോസസ്സിംഗിന്റെ ശൃംഖലയിലെ ഒരു നിർണായക കണ്ണിയായി മിഡിൽവെയർ പ്രവർത്തിക്കുന്നു.

ഈ സമഗ്രമായ ഗൈഡ് ഫാസ്റ്റ്‌എപിഐയിൽ പുതുതായി വരുന്നവർ മുതൽ തങ്ങളുടെ അറിവ് ആഴത്തിലാക്കാൻ ആഗ്രഹിക്കുന്ന പരിചയസമ്പന്നരായ പ്രൊഫഷണലുകൾ വരെയുള്ള ആഗോള ഡെവലപ്പർമാർക്കായി രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്. ഞങ്ങൾ മിഡിൽവെയറിന്റെ പ്രധാന ആശയങ്ങൾ പര്യവേക്ഷണം ചെയ്യുകയും, കസ്റ്റം സൊല്യൂഷനുകൾ എങ്ങനെ നിർമ്മിക്കാമെന്ന് കാണിക്കുകയും, പ്രായോഗികവും യഥാർത്ഥവുമായ ഉപയോഗ കേസുകളിലൂടെ നിങ്ങളെ കൊണ്ടുപോകുകയും ചെയ്യും. ഇത് പൂർത്തിയാകുമ്പോഴേക്കും, കൂടുതൽ ശക്തവും സുരക്ഷിതവും കാര്യക്ഷമവുമായ എപിഐകൾ നിർമ്മിക്കാൻ മിഡിൽവെയർ പ്രയോജനപ്പെടുത്താൻ നിങ്ങൾ സജ്ജരാകും.

വെബ് ഫ്രെയിംവർക്കുകളുടെ പശ്ചാത്തലത്തിൽ എന്താണ് മിഡിൽവെയർ?

കോഡിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, ഈ ആശയം മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്. നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ റിക്വസ്റ്റ്-റെസ്‌പോൺസ് സൈക്കിളിനെ ഒരു പൈപ്പ്ലൈൻ അല്ലെങ്കിൽ ഒരു അസംബ്ലി ലൈനായി സങ്കൽപ്പിക്കുക. ഒരു ക്ലയിന്റ് നിങ്ങളുടെ എപിഐയിലേക്ക് ഒരു റിക്വസ്റ്റ് അയയ്‌ക്കുമ്പോൾ, അത് തൽക്ഷണം നിങ്ങളുടെ എൻഡ്‌പോയിന്റ് ലോജിക്കിൽ എത്തുന്നില്ല. പകരം, അത് നിരവധി പ്രോസസ്സിംഗ് ഘട്ടങ്ങളിലൂടെ കടന്നുപോകുന്നു. അതുപോലെ, നിങ്ങളുടെ എൻഡ്‌പോയിന്റ് ഒരു റെസ്‌പോൺസ് ഉണ്ടാക്കുമ്പോൾ, അത് ക്ലയിന്റിലേക്ക് എത്തുന്നതിന് മുമ്പ് ഈ ഘട്ടങ്ങളിലൂടെ തിരികെ സഞ്ചരിക്കുന്നു. മിഡിൽവെയർ ഘടകങ്ങൾ ഈ പൈപ്പ്ലൈനിലെ ഘട്ടങ്ങളാണ്.

ഒരു ജനപ്രിയമായ ഉപമയാണ് ഉള്ളി മാതൃക (onion model). ഉള്ളിയുടെ കാതൽ നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ ബിസിനസ്സ് ലോജിക് (എൻഡ്‌പോയിന്റ്) ആണ്. കാതലിന് ചുറ്റുമുള്ള ഉള്ളിയുടെ ഓരോ പാളിയും ഓരോ മിഡിൽവെയറാണ്. കാതലിൽ എത്താൻ ഒരു റിക്വസ്റ്റിന് ഓരോ പുറം പാളിയും കടന്നുപോകണം, റെസ്‌പോൺസ് അതേ പാളികളിലൂടെ പുറത്തേക്ക് തിരികെ സഞ്ചരിക്കുന്നു. ഓരോ പാളിക്കും ഉള്ളിലേക്ക് വരുന്ന റിക്വസ്റ്റിനെയും പുറത്തേക്ക് പോകുന്ന റെസ്‌പോൺസിനെയും പരിശോധിക്കാനും പരിഷ്കരിക്കാനും കഴിയും.

ചുരുക്കത്തിൽ, മിഡിൽവെയർ എന്നത് ഒരു ഫംഗ്‌ഷനോ ക്ലാസോ ആണ്, അതിന് റിക്വസ്റ്റ് ഒബ്ജക്റ്റ്, റെസ്‌പോൺസ് ഒബ്ജക്റ്റ്, ആപ്ലിക്കേഷന്റെ റിക്വസ്റ്റ്-റെസ്‌പോൺസ് സൈക്കിളിലെ അടുത്ത മിഡിൽവെയർ എന്നിവയിലേക്ക് ആക്‌സസ് ഉണ്ട്. അതിന്റെ പ്രാഥമിക ലക്ഷ്യങ്ങളിൽ ഇവ ഉൾപ്പെടുന്നു:

• കോഡ് പ്രവർത്തിപ്പിക്കുക: ലോഗിംഗ് അല്ലെങ്കിൽ പ്രകടന നിരീക്ഷണം പോലുള്ള ഓരോ ഇൻകമിംഗ് റിക്വസ്റ്റിനും വേണ്ടിയുള്ള പ്രവർത്തനങ്ങൾ നടത്തുക.
• റിക്വസ്റ്റും റെസ്‌പോൺസും പരിഷ്കരിക്കുക: ഹെഡറുകൾ ചേർക്കുക, റെസ്‌പോൺസ് ബോഡികൾ കംപ്രസ് ചെയ്യുക, അല്ലെങ്കിൽ ഡാറ്റ ഫോർമാറ്റുകൾ മാറ്റുക.
• സൈക്കിൾ ചെറുതാക്കുക (Short-circuiting): റിക്വസ്റ്റ്-റെസ്‌പോൺസ് സൈക്കിൾ നേരത്തെ അവസാനിപ്പിക്കുക. ഉദാഹരണത്തിന്, ഒരു ഓതന്റിക്കേഷൻ മിഡിൽവെയറിന് ഒരു ഓതന്റിക്കേറ്റ് ചെയ്യാത്ത റിക്വസ്റ്റിനെ അത് ലക്ഷ്യസ്ഥാനത്ത് എത്തുന്നതിന് മുമ്പുതന്നെ തടയാൻ കഴിയും.
• ആഗോള കാര്യങ്ങൾ കൈകാര്യം ചെയ്യുക: എറർ ഹാൻഡ്‌ലിംഗ്, കോർസ് (ക്രോസ്-ഒറിജിൻ റിസോഴ്സ് ഷെയറിംഗ്), സെഷൻ മാനേജ്‌മെന്റ് തുടങ്ങിയ പൊതുവായ കാര്യങ്ങൾ ഒരു കേന്ദ്രീകൃത സ്ഥലത്ത് കൈകാര്യം ചെയ്യുക.

ഫാസ്റ്റ്‌എപിഐ നിർമ്മിച്ചിരിക്കുന്നത് സ്റ്റാർലെറ്റ് ടൂൾകിറ്റിന് മുകളിലാണ്, ഇത് എഎസ്ജിഐ (അസിൻക്രണസ് സെർവർ ഗേറ്റ്‌വേ ഇന്റർഫേസ്) സ്റ്റാൻഡേർഡിന്റെ ശക്തമായ ഒരു നിർവ്വഹണം നൽകുന്നു. മിഡിൽവെയർ എഎസ്ജിഐയിലെ ഒരു അടിസ്ഥാന ആശയമാണ്, ഇത് ഫാസ്റ്റ്‌എപിഐ ഇക്കോസിസ്റ്റത്തിലെ ഒരു പ്രധാന ഘടകമാക്കി മാറ്റുന്നു.

ഏറ്റവും ലളിതമായ രൂപം: ഡെക്കറേറ്റർ ഉപയോഗിച്ചുള്ള ഫാസ്റ്റ്‌എപിഐ മിഡിൽവെയർ

ഫാസ്റ്റ്‌എപിഐ @app.middleware("http") ഡെക്കറേറ്റർ ഉപയോഗിച്ച് മിഡിൽവെയർ ചേർക്കാൻ ലളിതമായ ഒരു മാർഗം നൽകുന്നു. ഓരോ എച്ച്ടിടിപി റിക്വസ്റ്റിനും പ്രവർത്തിപ്പിക്കേണ്ട ലളിതവും സ്വയം ഉൾക്കൊള്ളുന്നതുമായ ലോജിക്കിന് ഇത് അനുയോജ്യമാണ്.

നമുക്ക് ഒരു ക്ലാസിക് ഉദാഹരണം ഉണ്ടാക്കാം: ഓരോ റിക്വസ്റ്റിന്റെയും പ്രോസസ്സിംഗ് സമയം കണക്കാക്കുകയും അത് റെസ്‌പോൺസ് ഹെഡറുകളിൽ ചേർക്കുകയും ചെയ്യുന്ന ഒരു മിഡിൽവെയർ. പ്രകടന നിരീക്ഷണത്തിന് ഇത് അവിശ്വസനീയമാംവിധം ഉപയോഗപ്രദമാണ്.

ഉദാഹരണം: ഒരു പ്രോസസ്-ടൈം മിഡിൽവെയർ

ആദ്യം, നിങ്ങൾക്ക് ഫാസ്റ്റ്‌എപിഐയും യുവിക്കോൺ പോലുള്ള ഒരു എഎസ്ജിഐ സെർവറും ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക:

pip install fastapi uvicorn

ഇനി, main.py എന്ന ഫയലിൽ കോഡ് എഴുതാം:

import time

from fastapi import FastAPI, Request

app = FastAPI()

# മിഡിൽവെയർ ഫംഗ്‌ഷൻ നിർവചിക്കുക

@app.middleware("http")

async def add_process_time_header(request: Request, call_next):

# റിക്വസ്റ്റ് വരുമ്പോൾ ആരംഭ സമയം രേഖപ്പെടുത്തുക

start_time = time.time()

# അടുത്ത മിഡിൽവെയറിലേക്കോ എൻഡ്‌പോയിന്റിലേക്കോ പോകുക

response = await call_next(request)

# പ്രോസസ്സിംഗ് സമയം കണക്കാക്കുക

process_time = time.time() - start_time

# റെസ്‌പോൺസിലേക്ക് കസ്റ്റം ഹെഡർ ചേർക്കുക

response.headers["X-Process-Time"] = str(process_time)

return response

@app.get("/")

async def root():

# എന്തെങ്കിലും പ്രവൃത്തി സിമുലേറ്റ് ചെയ്യുക

time.sleep(0.5)

return {"message": "Hello, World!"}

ഈ ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നതിന്, ഈ കമാൻഡ് ഉപയോഗിക്കുക:

uvicorn main:app --reload

ഇപ്പോൾ, നിങ്ങൾ cURL പോലുള്ള ഒരു ടൂൾ അല്ലെങ്കിൽ പോസ്റ്റ്മാൻ പോലുള്ള ഒരു എപിഐ ക്ലയിന്റ് ഉപയോഗിച്ച് http://127.0.0.1:8000 എന്നതിലേക്ക് ഒരു റിക്വസ്റ്റ് അയച്ചാൽ, റെസ്‌പോൺസിൽ ഏകദേശം 0.5 സെക്കൻഡ് മൂല്യമുള്ള X-Process-Time എന്ന പുതിയ ഹെഡർ കാണാം.

കോഡ് വിശദീകരണം:

• @app.middleware("http"): ഈ ഡെക്കറേറ്റർ നമ്മുടെ ഫംഗ്‌ഷനെ ഒരു എച്ച്ടിടിപി മിഡിൽവെയറായി രജിസ്റ്റർ ചെയ്യുന്നു.
• async def add_process_time_header(request: Request, call_next):: മിഡിൽവെയർ ഫംഗ്‌ഷൻ അസിൻക്രണസ് ആയിരിക്കണം. ഇതിന് ഇൻകമിംഗ് Request ഒബ്ജക്റ്റും call_next എന്ന പ്രത്യേക ഫംഗ്‌ഷനും ലഭിക്കുന്നു.
• response = await call_next(request): ഇതാണ് ഏറ്റവും നിർണായകമായ വരി. call_next റിക്വസ്റ്റിനെ പൈപ്പ്ലൈനിലെ അടുത്ത ഘട്ടത്തിലേക്ക് (മറ്റൊരു മിഡിൽവെയർ അല്ലെങ്കിൽ യഥാർത്ഥ പാത്ത് ഓപ്പറേഷൻ) കൈമാറുന്നു. നിങ്ങൾ ഈ കോളിനെ must `await` ചെയ്യണം. എൻഡ്‌പോയിന്റ് ഉണ്ടാക്കുന്ന Response ഒബ്ജക്റ്റാണ് ഇതിന്റെ ഫലം.
• response.headers[...] = ...: എൻഡ്‌പോയിന്റിൽ നിന്ന് റെസ്‌പോൺസ് ലഭിച്ച ശേഷം, നമുക്ക് അത് പരിഷ്കരിക്കാൻ കഴിയും, ഈ സാഹചര്യത്തിൽ ഒരു കസ്റ്റം ഹെഡർ ചേർത്തുകൊണ്ട്.
• return response: അവസാനമായി, പരിഷ്കരിച്ച റെസ്‌പോൺസ് ക്ലയിന്റിലേക്ക് അയയ്‌ക്കുന്നതിനായി തിരികെ നൽകുന്നു.

ക്ലാസുകൾ ഉപയോഗിച്ച് നിങ്ങളുടെ സ്വന്തം കസ്റ്റം മിഡിൽവെയർ നിർമ്മിക്കുന്നു

ഡെക്കറേറ്റർ രീതി ലളിതമാണെങ്കിലും, കൂടുതൽ സങ്കീർണ്ണമായ സാഹചര്യങ്ങളിൽ ഇത് പരിമിതപ്പെടുത്താം, പ്രത്യേകിച്ചും നിങ്ങളുടെ മിഡിൽവെയറിന് കോൺഫിഗറേഷൻ ആവശ്യമായി വരുമ്പോഴോ അല്ലെങ്കിൽ ചില ആന്തരിക സ്റ്റേറ്റ് കൈകാര്യം ചെയ്യേണ്ടിവരുമ്പോഴോ. ഈ സാഹചര്യങ്ങളിൽ, ഫാസ്റ്റ്‌എപിഐ (സ്റ്റാർലെറ്റ് വഴി) BaseHTTPMiddleware ഉപയോഗിച്ച് ക്ലാസ്-ബേസ്ഡ് മിഡിൽവെയറിനെ പിന്തുണയ്ക്കുന്നു.

ഒരു ക്ലാസ്-ബേസ്ഡ് സമീപനം മികച്ച ഘടന നൽകുന്നു, അതിന്റെ കൺസ്ട്രക്ടറിൽ ഡിപൻഡൻസി ഇൻജെക്ഷൻ അനുവദിക്കുന്നു, സങ്കീർണ്ണമായ ലോജിക്കിന് പൊതുവെ കൂടുതൽ പരിപാലിക്കാൻ എളുപ്പമാണ്. പ്രധാന ലോജിക് ഒരു അസിൻക്രണസ് dispatch മെത്തേഡിലാണ്.

ഉദാഹരണം: ഒരു ക്ലാസ്-ബേസ്ഡ് എപിഐ കീ ഓതന്റിക്കേഷൻ മിഡിൽവെയർ

നമുക്ക് നമ്മുടെ എപിഐ സുരക്ഷിതമാക്കുന്ന കൂടുതൽ പ്രായോഗികമായ ഒരു മിഡിൽവെയർ നിർമ്മിക്കാം. ഇത് X-API-Key എന്ന ഒരു പ്രത്യേക ഹെഡർ പരിശോധിക്കുകയും, കീ ഇല്ലെങ്കിൽ അല്ലെങ്കിൽ അസാധുവാണെങ്കിൽ, ഉടനടി ഒരു 403 Forbidden എറർ റെസ്‌പോൺസ് നൽകുകയും ചെയ്യും. ഇത് റിക്വസ്റ്റിനെ "ഷോർട്ട്-സർക്യൂട്ട്" ചെയ്യുന്നതിനുള്ള ഒരു ഉദാഹരണമാണ്.

main.py ൽ:

from fastapi import FastAPI, Request

from fastapi.responses import JSONResponse

from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint

from starlette.responses import Response

# സാധുവായ എപിഐ കീകളുടെ ഒരു ലിസ്റ്റ്. ഒരു യഥാർത്ഥ ആപ്ലിക്കേഷനിൽ, ഇത് ഒരു ഡാറ്റാബേസിൽ നിന്നോ സുരക്ഷിതമായ ഒരു വോൾട്ടിൽ നിന്നോ ആയിരിക്കും.

VALID_API_KEYS = ["my-super-secret-key", "another-valid-key"]

class APIKeyMiddleware(BaseHTTPMiddleware):

async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:

api_key = request.headers.get("X-API-Key")

if api_key not in VALID_API_KEYS:

# റിക്വസ്റ്റ് ഷോർട്ട്-സർക്യൂട്ട് ചെയ്ത് ഒരു എറർ റെസ്‌പോൺസ് നൽകുക

return JSONResponse(

status_code=403,

content={"detail": "Forbidden: Invalid or missing API Key"}

)

# കീ സാധുവാണെങ്കിൽ, റിക്വസ്റ്റുമായി മുന്നോട്ട് പോകുക

response = await call_next(request)

return response

app = FastAPI()

# ആപ്ലിക്കേഷനിലേക്ക് മിഡിൽവെയർ ചേർക്കുക

app.add_middleware(APIKeyMiddleware)

@app.get("/")

async def root():

return {"message": "Welcome to the secure zone!"}

ഇപ്പോൾ, നിങ്ങൾ ഈ ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുമ്പോൾ:

• ഒരു റിക്വസ്റ്റ് ഇല്ലാതെ X-API-Key ഹെഡർ (അല്ലെങ്കിൽ തെറ്റായ മൂല്യത്തോടെ) വന്നാൽ 403 സ്റ്റാറ്റസ് കോഡും JSON എറർ സന്ദേശവും ലഭിക്കും.
• X-API-Key: my-super-secret-key എന്ന ഹെഡറോടു കൂടിയ ഒരു റിക്വസ്റ്റ് വിജയിക്കുകയും 200 OK റെസ്‌പോൺസ് ലഭിക്കുകയും ചെയ്യും.

ഈ പാറ്റേൺ വളരെ ശക്തമാണ്. / എന്നതിലെ എൻഡ്‌പോയിന്റ് കോഡിന് എപിഐ കീ വാലിഡേഷനെക്കുറിച്ച് ഒന്നും അറിയേണ്ടതില്ല; ആ വിഷയം പൂർണ്ണമായും മിഡിൽവെയർ ലെയറിലേക്ക് വേർതിരിച്ചിരിക്കുന്നു.

മിഡിൽവെയറിന്റെ സാധാരണവും ശക്തവുമായ ഉപയോഗങ്ങൾ

ക്രോസ്-കട്ടിംഗ് കാര്യങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള മികച്ച ഉപകരണമാണ് മിഡിൽവെയർ. നമുക്ക് ഏറ്റവും സാധാരണവും സ്വാധീനമുള്ളതുമായ ചില ഉപയോഗങ്ങൾ പര്യവേക്ഷണം ചെയ്യാം.

1. കേന്ദ്രീകൃത ലോഗിംഗ്

പ്രൊഡക്ഷൻ ആപ്ലിക്കേഷനുകൾക്ക് സമഗ്രമായ ലോഗിംഗ് ഒഴിച്ചുകൂടാനാവാത്തതാണ്. ഓരോ റിക്വസ്റ്റിനെക്കുറിച്ചും അതിനോടനുബന്ധിച്ചുള്ള റെസ്‌പോൺസിനെക്കുറിച്ചുമുള്ള നിർണായക വിവരങ്ങൾ ലോഗ് ചെയ്യാൻ കഴിയുന്ന ഒരൊറ്റ പോയിന്റ് സൃഷ്ടിക്കാൻ മിഡിൽവെയർ നിങ്ങളെ അനുവദിക്കുന്നു.

ഉദാഹരണ ലോഗിംഗ് മിഡിൽവെയർ:

import logging

from fastapi import FastAPI, Request

import time

logging.basicConfig(level=logging.INFO)

logger = logging.getLogger(__name__)

app = FastAPI()

@app.middleware("http")

async def logging_middleware(request: Request, call_next):

start_time = time.time()

# റിക്വസ്റ്റ് വിശദാംശങ്ങൾ ലോഗ് ചെയ്യുക

logger.info(f"Incoming request: {request.method} {request.url.path}")

response = await call_next(request)

process_time = time.time() - start_time

# റെസ്‌പോൺസ് വിശദാംശങ്ങൾ ലോഗ് ചെയ്യുക

logger.info(f"Response status: {response.status_code} | Process time: {process_time:.4f}s")

return response

ഈ മിഡിൽവെയർ റിക്വസ്റ്റ് മെത്തേഡും പാത്തും വരുമ്പോഴും, റെസ്‌പോൺസ് സ്റ്റാറ്റസ് കോഡും മൊത്തം പ്രോസസ്സിംഗ് സമയവും പോകുമ്പോഴും ലോഗ് ചെയ്യുന്നു. ഇത് നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ ട്രാഫിക്കിലേക്ക് വിലയേറിയ ദൃശ്യപരത നൽകുന്നു.

2. ഗ്ലോബൽ എറർ ഹാൻഡ്‌ലിംഗ്

ഡിഫോൾട്ടായി, നിങ്ങളുടെ കോഡിലെ കൈകാര്യം ചെയ്യാത്ത ഒരു എക്സെപ്ഷൻ 500 ഇന്റേണൽ സെർവർ എററിന് കാരണമാകും, ഇത് സ്റ്റാക്ക് ട്രെയ്സുകളും നിർവ്വഹണ വിശദാംശങ്ങളും ക്ലയിന്റിന് വെളിപ്പെടുത്താൻ സാധ്യതയുണ്ട്. ഒരു ഗ്ലോബൽ എറർ ഹാൻഡ്‌ലിംഗ് മിഡിൽവെയറിന് എല്ലാ എക്സെപ്ഷനുകളും പിടിച്ചെടുക്കാനും, ആന്തരിക അവലോകനത്തിനായി അവ ലോഗ് ചെയ്യാനും, ഒരു സ്റ്റാൻഡേർഡ്, ഉപയോക്തൃ-സൗഹൃദ എറർ റെസ്‌പോൺസ് നൽകാനും കഴിയും.

ഉദാഹരണ എറർ ഹാൻഡ്‌ലിംഗ് മിഡിൽവെയർ:

from fastapi import FastAPI, Request

from fastapi.responses import JSONResponse

import logging

logger = logging.getLogger(__name__)

app = FastAPI()

@app.middleware("http")

async def error_handling_middleware(request: Request, call_next):

try:

return await call_next(request)

except Exception as e:

logger.error(f"An unhandled error occurred: {e}", exc_info=True)

return JSONResponse(

status_code=500,

content={"detail": "An internal server error occurred. Please try again later."}

)

@app.get("/error")

async def cause_error():

return 1 / 0 # ഇത് ഒരു ZeroDivisionError ഉണ്ടാക്കും

ഈ മിഡിൽവെയർ ഉള്ളതിനാൽ, /error എന്നതിലേക്കുള്ള ഒരു റിക്വസ്റ്റ് സെർവർ ക്രാഷ് ചെയ്യുകയോ സ്റ്റാക്ക് ട്രെയ്സ് വെളിപ്പെടുത്തുകയോ ചെയ്യില്ല. പകരം, അത് മനോഹരമായി 500 സ്റ്റാറ്റസ് കോഡും ഒരു വൃത്തിയുള്ള JSON ബോഡിയും നൽകും, അതേസമയം പൂർണ്ണമായ പിശക് ഡെവലപ്പർമാർക്ക് അന്വേഷിക്കുന്നതിനായി സെർവർ-സൈഡിൽ ലോഗ് ചെയ്യപ്പെടും.

3. കോർസ് (ക്രോസ്-ഒറിജിൻ റിസോഴ്സ് ഷെയറിംഗ്)

നിങ്ങളുടെ ഫ്രണ്ട്എൻഡ് ആപ്ലിക്കേഷൻ നിങ്ങളുടെ ഫാസ്റ്റ്‌എപിഐ ബാക്കെൻഡിൽ നിന്ന് വ്യത്യസ്തമായ ഡൊമെയ്ൻ, പ്രോട്ടോക്കോൾ, അല്ലെങ്കിൽ പോർട്ടിൽ നിന്നാണ് പ്രവർത്തിക്കുന്നതെങ്കിൽ, ബ്രൗസറുകൾ സെയിം-ഒറിജിൻ പോളിസി കാരണം റിക്വസ്റ്റുകൾ തടയും. ഈ നയം ലഘൂകരിക്കുന്നതിനുള്ള സംവിധാനമാണ് കോർസ്. ഫാസ്റ്റ്‌എപിഐ ഈ ആവശ്യത്തിനായി പ്രത്യേകം ക്രമീകരിക്കാവുന്ന ഒരു CORSMiddleware നൽകുന്നു.

ഉദാഹരണ കോർസ് കോൺഫിഗറേഷൻ:

from fastapi import FastAPI

from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

# അനുവദനീയമായ ഒറിജിനുകളുടെ ലിസ്റ്റ് നിർവചിക്കുക. പൊതുവായ എപിഐകൾക്ക് "*" ഉപയോഗിക്കുക, എന്നാൽ മികച്ച സുരക്ഷയ്ക്കായി കൃത്യമായിരിക്കുക.

origins = [

"http://localhost:3000",

"https://my-production-frontend.com",

]

app.add_middleware(

CORSMiddleware,

allow_origins=origins,

allow_credentials=True, # ക്രോസ്-ഒറിജിൻ റിക്വസ്റ്റുകളിൽ കുക്കികൾ ഉൾപ്പെടുത്താൻ അനുവദിക്കുക

allow_methods=["*"], # എല്ലാ സ്റ്റാൻഡേർഡ് HTTP രീതികളും അനുവദിക്കുക

allow_headers=["*"], # എല്ലാ ഹെഡറുകളും അനുവദിക്കുക

)

വേർപിരിഞ്ഞ ഫ്രണ്ട്എൻഡ് ഉള്ള ഏത് പ്രോജക്റ്റിലും നിങ്ങൾ ചേർക്കാൻ സാധ്യതയുള്ള ആദ്യത്തെ മിഡിൽവെയറുകളിൽ ഒന്നാണിത്, ഇത് ഒരൊറ്റ കേന്ദ്രീകൃത സ്ഥലത്ത് നിന്ന് ക്രോസ്-ഒറിജിൻ നയങ്ങൾ കൈകാര്യം ചെയ്യുന്നത് ലളിതമാക്കുന്നു.

4. ജിസിപ്പ് കംപ്രഷൻ

എച്ച്ടിടിപി റെസ്‌പോൺസുകൾ കംപ്രസ് ചെയ്യുന്നത് അവയുടെ വലുപ്പം ഗണ്യമായി കുറയ്ക്കുകയും, ക്ലയിന്റുകൾക്ക് വേഗത്തിലുള്ള ലോഡ് സമയത്തിനും കുറഞ്ഞ ബാൻഡ്‌വിഡ്ത്ത് ചെലവിനും ഇടയാക്കുകയും ചെയ്യും. ഇത് യാന്ത്രികമായി കൈകാര്യം ചെയ്യാൻ ഫാസ്റ്റ്‌എപിഐയിൽ ഒരു GZipMiddleware ഉണ്ട്.

ഉദാഹരണ ജിസിപ്പ് മിഡിൽവെയർ:

from fastapi import FastAPI

from fastapi.middleware.gzip import GZipMiddleware

app = FastAPI()

# ജിസിപ്പ് മിഡിൽവെയർ ചേർക്കുക. നിങ്ങൾക്ക് കംപ്രഷനുവേണ്ടി ഒരു മിനിമം വലുപ്പം സജ്ജമാക്കാം.

app.add_middleware(GZipMiddleware, minimum_size=1000)

@app.get("/")

async def root():

# ഈ റെസ്‌പോൺസ് ചെറുതാണ്, ജിസിപ്പ് ചെയ്യപ്പെടില്ല.

return {"message": "Hello World"}

@app.get("/large-data")

async def large_data():

# ഈ വലിയ റെസ്‌പോൺസ് മിഡിൽവെയർ യാന്ത്രികമായി ജിസിപ്പ് ചെയ്യും.

return {"data": "a_very_long_string..." * 1000}

ഈ മിഡിൽവെയർ ഉപയോഗിച്ച്, 1000 ബൈറ്റിൽ കൂടുതൽ വലുപ്പമുള്ള ഏത് റെസ്‌പോൺസും ക്ലയിന്റ് ജിസിപ്പ് എൻകോഡിംഗ് സ്വീകരിക്കുന്നുവെന്ന് സൂചിപ്പിച്ചാൽ കംപ്രസ് ചെയ്യപ്പെടും (ഇന്നത്തെ എല്ലാ ആധുനിക ബ്രൗസറുകളും ക്ലയിന്റുകളും ഇത് ചെയ്യാറുണ്ട്).

വിപുലമായ ആശയങ്ങളും മികച്ച രീതികളും

നിങ്ങൾ മിഡിൽവെയറിൽ കൂടുതൽ പ്രാവീണ്യം നേടുമ്പോൾ, വൃത്തിയുള്ളതും കാര്യക്ഷമവും പ്രവചിക്കാവുന്നതുമായ കോഡ് എഴുതുന്നതിന് ചില സൂക്ഷ്മതകളും മികച്ച രീതികളും മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ്.

1. മിഡിൽവെയറിന്റെ ക്രമം പ്രധാനമാണ്!

ഇതാണ് ഓർമ്മിക്കേണ്ട ഏറ്റവും നിർണായകമായ നിയമം. മിഡിൽവെയർ ആപ്ലിക്കേഷനിൽ ചേർത്ത ക്രമത്തിലാണ് പ്രോസസ്സ് ചെയ്യുന്നത്. ആദ്യം ചേർത്ത മിഡിൽവെയർ "ഉള്ളി"യുടെ ഏറ്റവും പുറമെയുള്ള പാളിയാണ്.

ഈ സജ്ജീകരണം പരിഗണിക്കുക:

app.add_middleware(ErrorHandlingMiddleware) # ഏറ്റവും പുറത്ത്

app.add_middleware(LoggingMiddleware)

app.add_middleware(AuthenticationMiddleware) # ഏറ്റവും ഉള്ളിൽ

ഒരു റിക്വസ്റ്റിന്റെ ഒഴുക്ക് ഇങ്ങനെയായിരിക്കും:

1. ErrorHandlingMiddleware റിക്വസ്റ്റ് സ്വീകരിക്കുന്നു. അത് അതിന്റെ `call_next` നെ ഒരു `try...except` ബ്ലോക്കിൽ പൊതിയുന്നു.
2. അത് `next` നെ വിളിക്കുകയും, റിക്വസ്റ്റ് LoggingMiddleware ലേക്ക് കൈമാറുകയും ചെയ്യുന്നു.
3. LoggingMiddleware റിക്വസ്റ്റ് സ്വീകരിച്ച്, അത് ലോഗ് ചെയ്ത്, `next` നെ വിളിക്കുന്നു.
4. AuthenticationMiddleware റിക്വസ്റ്റ് സ്വീകരിച്ച്, ക്രെഡൻഷ്യലുകൾ സാധൂകരിച്ച്, `next` നെ വിളിക്കുന്നു.
5. റിക്വസ്റ്റ് ഒടുവിൽ എൻഡ്‌പോയിന്റിൽ എത്തുന്നു.
6. എൻഡ്‌പോയിന്റ് ഒരു റെസ്‌പോൺസ് നൽകുന്നു.
7. AuthenticationMiddleware റെസ്‌പോൺസ് സ്വീകരിച്ച് മുകളിലേക്ക് കൈമാറുന്നു.
8. LoggingMiddleware റെസ്‌പോൺസ് സ്വീകരിച്ച്, അത് ലോഗ് ചെയ്ത്, മുകളിലേക്ക് കൈമാറുന്നു.
9. ErrorHandlingMiddleware അവസാന റെസ്‌പോൺസ് സ്വീകരിച്ച് ക്ലയിന്റിന് തിരികെ നൽകുന്നു.

ഈ ക്രമം യുക്തിസഹമാണ്: എറർ ഹാൻഡ്‌ലർ പുറത്തായതിനാൽ മറ്റ് മിഡിൽവെയറുകൾ ഉൾപ്പെടെയുള്ള തുടർന്നുള്ള ഏത് ലെയറിലെയും പിശകുകൾ പിടിക്കാൻ അതിന് കഴിയും. ഓതന്റിക്കേഷൻ ലെയർ ഉള്ളിലാണ്, അതിനാൽ നിരസിക്കാൻ പോകുന്ന റിക്വസ്റ്റുകൾ ലോഗ് ചെയ്യുകയോ പ്രോസസ്സ് ചെയ്യുകയോ ചെയ്യേണ്ടതില്ല.

2. `request.state` ഉപയോഗിച്ച് ഡാറ്റ കൈമാറുന്നു

ചിലപ്പോൾ, ഒരു മിഡിൽവെയറിന് എൻഡ്‌പോയിന്റിലേക്ക് വിവരങ്ങൾ കൈമാറേണ്ടതുണ്ട്. ഉദാഹരണത്തിന്, ഒരു ഓതന്റിക്കേഷൻ മിഡിൽവെയർ ഒരു JWT ഡീകോഡ് ചെയ്ത് ഉപയോക്താവിന്റെ ഐഡി എടുത്തേക്കാം. ഈ യൂസർ ഐഡി പാത്ത് ഓപ്പറേഷൻ ഫംഗ്‌ഷന് എങ്ങനെ ലഭ്യമാക്കാം?

റിക്വസ്റ്റ് ഒബ്ജക്റ്റ് നേരിട്ട് പരിഷ്കരിക്കുന്നത് തെറ്റായ മാർഗമാണ്. request.state ഒബ്ജക്റ്റ് ഉപയോഗിക്കുന്നതാണ് ശരിയായ മാർഗം. ഈ ആവശ്യത്തിനായി നൽകിയിട്ടുള്ള ഒരു ലളിതമായ, ശൂന്യമായ ഒബ്ജക്റ്റാണിത്.

ഉദാഹരണം: മിഡിൽവെയറിൽ നിന്ന് ഉപയോക്തൃ ഡാറ്റ കൈമാറുന്നു

# നിങ്ങളുടെ ഓതന്റിക്കേഷൻ മിഡിൽവെയറിന്റെ ഡിസ്പാച്ച് മെത്തേഡിൽ:

# ... ടോക്കൺ സാധൂകരിച്ച് ഉപയോക്താവിനെ ഡീകോഡ് ചെയ്ത ശേഷം ...

user_data = {"id": 123, "username": "global_dev"}

request.state.user = user_data

response = await call_next(request)

# നിങ്ങളുടെ എൻഡ്‌പോയിന്റിൽ:

@app.get("/profile")

async def get_user_profile(request: Request):

current_user = request.state.user

return {"profile_for": current_user}

ഇത് ലോജിക്ക് വൃത്തിയായി സൂക്ഷിക്കുകയും Request ഒബ്ജക്റ്റിന്റെ നെയിംസ്പേസ് മലിനമാക്കുന്നത് ഒഴിവാക്കുകയും ചെയ്യുന്നു.

3. പ്രകടന പരിഗണനകൾ

മിഡിൽവെയർ ശക്തമാണെങ്കിലും, ഓരോ ലെയറും ഒരു ചെറിയ അളവിലുള്ള ഓവർഹെഡ് ചേർക്കുന്നു. ഉയർന്ന പ്രകടനമുള്ള ആപ്ലിക്കേഷനുകൾക്കായി, ഈ കാര്യങ്ങൾ മനസ്സിൽ വയ്ക്കുക:

• അതിനെ ലളിതമായി നിലനിർത്തുക: മിഡിൽവെയർ ലോജിക്ക് കഴിയുന്നത്ര വേഗതയേറിയതും കാര്യക്ഷമവുമായിരിക്കണം.
• അസിൻക്രണസ് ആയിരിക്കുക: നിങ്ങളുടെ മിഡിൽവെയറിന് I/O ഓപ്പറേഷനുകൾ (ഒരു ഡാറ്റാബേസ് പരിശോധന പോലെ) നടത്തണമെങ്കിൽ, സെർവറിന്റെ ഇവന്റ് ലൂപ്പ് ബ്ലോക്ക് ചെയ്യാതിരിക്കാൻ അത് പൂർണ്ണമായും `async` ആണെന്ന് ഉറപ്പാക്കുക.
• ഉദ്ദേശ്യത്തോടെ ഉപയോഗിക്കുക: നിങ്ങൾക്ക് ആവശ്യമില്ലാത്ത മിഡിൽവെയർ ചേർക്കരുത്. ഓരോന്നും കോൾ സ്റ്റാക്ക് ഡെപ്ത്തും പ്രോസസ്സിംഗ് സമയവും വർദ്ധിപ്പിക്കുന്നു.

4. നിങ്ങളുടെ മിഡിൽവെയർ ടെസ്റ്റ് ചെയ്യുക

മിഡിൽവെയർ നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ ലോജിക്കിന്റെ ഒരു നിർണായക ഭാഗമാണ്, അത് സമഗ്രമായി ടെസ്റ്റ് ചെയ്യണം. ഫാസ്റ്റ്‌എപിഐയുടെ `TestClient` ഇത് ലളിതമാക്കുന്നു. ആവശ്യമായ വ്യവസ്ഥകളോടെയും അല്ലാതെയും (ഉദാഹരണത്തിന്, സാധുവായ എപിഐ കീ ഉപയോഗിച്ചും അല്ലാതെയും) റിക്വസ്റ്റുകൾ അയക്കുന്ന ടെസ്റ്റുകൾ നിങ്ങൾക്ക് എഴുതാനും മിഡിൽവെയർ പ്രതീക്ഷിച്ചതുപോലെ പ്രവർത്തിക്കുന്നുണ്ടോ എന്ന് ഉറപ്പുവരുത്താനും കഴിയും.

APIKeyMiddleware-നുള്ള ഉദാഹരണ ടെസ്റ്റ്:

from fastapi.testclient import TestClient

from .main import app # നിങ്ങളുടെ FastAPI ആപ്പ് ഇമ്പോർട്ട് ചെയ്യുക

client = TestClient(app)

def test_request_without_api_key_is_forbidden():

response = client.get("/")

assert response.status_code == 403

assert response.json() == {"detail": "Forbidden: Invalid or missing API Key"}

def test_request_with_valid_api_key_is_successful():

headers = {"X-API-Key": "my-super-secret-key"}

response = client.get("/", headers=headers)

assert response.status_code == 200

assert response.json() == {"message": "Welcome to the secure zone!"}

ഉപസംഹാരം

ആധുനിക വെബ് എപിഐകൾ നിർമ്മിക്കുന്ന ഏതൊരു ഡെവലപ്പർക്കും ഫാസ്റ്റ്‌എപിഐ മിഡിൽവെയർ ഒരു അടിസ്ഥാനപരവും ശക്തവുമായ ഉപകരണമാണ്. ഇത് ക്രോസ്-കട്ടിംഗ് കാര്യങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിന് മനോഹരവും പുനരുപയോഗിക്കാവുന്നതുമായ ഒരു മാർഗ്ഗം നൽകുന്നു, അവയെ നിങ്ങളുടെ പ്രധാന ബിസിനസ്സ് ലോജിക്കിൽ നിന്ന് വേർതിരിക്കുന്നു. ഓരോ റിക്വസ്റ്റും റെസ്‌പോൺസും തടസ്സപ്പെടുത്തി പ്രോസസ്സ് ചെയ്യുന്നതിലൂടെ, ശക്തമായ ലോഗിംഗ്, കേന്ദ്രീകൃത എറർ ഹാൻഡ്‌ലിംഗ്, കർശനമായ സുരക്ഷാ നയങ്ങൾ, കംപ്രഷൻ പോലുള്ള പ്രകടന മെച്ചപ്പെടുത്തലുകൾ എന്നിവ നടപ്പിലാക്കാൻ മിഡിൽവെയർ നിങ്ങളെ അനുവദിക്കുന്നു.

ലളിതമായ @app.middleware("http") ഡെക്കറേറ്റർ മുതൽ സങ്കീർണ്ണമായ, ക്ലാസ്-ബേസ്ഡ് സൊല്യൂഷനുകൾ വരെ, നിങ്ങളുടെ ആവശ്യങ്ങൾക്കനുസരിച്ച് ശരിയായ സമീപനം തിരഞ്ഞെടുക്കാനുള്ള വഴക്കം നിങ്ങൾക്കുണ്ട്. പ്രധാന ആശയങ്ങൾ, സാധാരണ ഉപയോഗങ്ങൾ, മിഡിൽവെയർ ക്രമീകരണം, സ്റ്റേറ്റ് മാനേജ്മെന്റ് പോലുള്ള മികച്ച രീതികൾ എന്നിവ മനസ്സിലാക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് കൂടുതൽ വൃത്തിയുള്ളതും സുരക്ഷിതവും ഉയർന്ന പരിപാലനക്ഷമതയുമുള്ള ഫാസ്റ്റ്‌എപിഐ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ കഴിയും.

ഇപ്പോൾ നിങ്ങളുടെ ഊഴമാണ്. നിങ്ങളുടെ അടുത്ത ഫാസ്റ്റ്‌എപിഐ പ്രോജക്റ്റിൽ കസ്റ്റം മിഡിൽവെയർ സംയോജിപ്പിക്കാൻ തുടങ്ങുക, നിങ്ങളുടെ എപിഐ ഡിസൈനിൽ ഒരു പുതിയ തലത്തിലുള്ള നിയന്ത്രണവും ചാരുതയും അൺലോക്ക് ചെയ്യുക. സാധ്യതകൾ വളരെ വലുതാണ്, ഈ ഫീച്ചറിൽ പ്രാവീണ്യം നേടുന്നത് നിങ്ങളെ കൂടുതൽ ഫലപ്രദവും കാര്യക്ഷമവുമായ ഒരു ഡെവലപ്പറാക്കി മാറ്റുമെന്നതിൽ സംശയമില്ല.